chore: centralize test mocking and add named helpers - #63

test/support/mock_event_store_helpers.ex (3)

170-177: Consider documenting the default count.

The default count: 6 presumably matches the aggregate's retry limit configuration. A brief note in the @doc explaining this coupling would help maintainers understand why this specific default was chosen.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/support/mock_event_store_helpers.ex` around lines 170 - 177, Update the
`@doc` for expect_too_many_retry_attempts to explicitly state that the default
count is 6 and that this value is chosen to match the aggregate's retry limit
configuration (so callers know the coupling); mention that the count can be
overridden via the opts parameter (e.g., opts[:count]) and that the function
calls expect_append_wrong_expected_version and expect_stream_empty with that
count so both mocks use the same retry attempt number.

---

199-200: Fallback event_type may be misleading.

For non-struct data, returning "Elixir.Commanded.EventStore.RecordedEvent" as the event type is semantically confusing—it suggests the event is a RecordedEvent rather than indicating an unknown/untyped event. Consider a clearer fallback:

♻️ Suggested alternatives

  defp infer_event_type(%{__struct__: struct}), do: to_string(struct)
- defp infer_event_type(_), do: "Elixir.Commanded.EventStore.RecordedEvent"
+ defp infer_event_type(_), do: "UnknownEvent"

Or require an explicit :event_type in opts for non-struct data.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/support/mock_event_store_helpers.ex` around lines 199 - 200, The
fallback in infer_event_type currently returns the misleading
"Elixir.Commanded.EventStore.RecordedEvent" for non-structs; change
infer_event_type to accept an optional opts (e.g., infer_event_type(data, opts
\\ [])) and return opts[:event_type] when provided, otherwise use a clear
default like "Elixir.UnknownEvent" (or "unknown") instead of
"Elixir.Commanded.EventStore.RecordedEvent"; update callers to pass opts where
non-struct event_type must be explicit.

---

71-75: Consider adding count option for API consistency.

Unlike expect_stream_empty/2 and other helpers, this function lacks a count option. For consistency and flexibility:

♻️ Suggested refactor

-  def expect_stream_not_found(stream_uuid) do
-    expect(MockEventStore, :stream_forward, fn _meta, ^stream_uuid, _from, _batch_size ->
+  def expect_stream_not_found(stream_uuid, opts \\ []) do
+    count = Keyword.get(opts, :count, 1)
+
+    expect(MockEventStore, :stream_forward, count, fn _meta, ^stream_uuid, _from, _batch_size ->
       {:error, :stream_not_found}
     end)
   end

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/support/mock_event_store_helpers.ex` around lines 71 - 75, The helper
expect_stream_not_found/1 is missing a count option for consistency; change it
to accept an optional count argument (e.g., def
expect_stream_not_found(stream_uuid, count \\ 0)) and use that count in the
expect for MockEventStore.stream_forward by matching the _batch_size argument to
the provided count (pin the count variable in the anonymous function head), and
update any callers to pass a count where needed so behavior matches
expect_stream_empty/2 and other helpers.

test/support/mock_event_store_helpers.ex (1)

181-243: Consider parameterizing version numbers in expect_concurrency_retry_succeeds/2.

The helper hardcodes versions 1, 2, 2 for the append/stream sequence. While this works for the current test cases, adding optional :expected_version and :reload_version parameters (similar to expect_wrong_expected_version_retry_succeeds/3) would make the helper more flexible for future scenarios.

The :counters usage for stateful mock behavior in expect_wrong_expected_version_retry_succeeds/3 is a clever approach that keeps the expectation self-contained.

♻️ Optional: Add version parameters for flexibility

-  def expect_concurrency_retry_succeeds(stream_uuid, concurrent_event) do
-    expect(MockEventStore, :append_to_stream, fn _meta, ^stream_uuid, 1, _events, _opts ->
+  def expect_concurrency_retry_succeeds(stream_uuid, concurrent_event, opts \\ []) do
+    expected_version = Keyword.get(opts, :expected_version, 1)
+    reload_version = Keyword.get(opts, :reload_version, 2)
+
+    expect(MockEventStore, :append_to_stream, fn _meta, ^stream_uuid, ^expected_version, _events, _opts ->
       {:error, :wrong_expected_version}
     end)

-    expect(MockEventStore, :stream_forward, fn _meta, ^stream_uuid, 2, _batch_size ->
+    expect(MockEventStore, :stream_forward, fn _meta, ^stream_uuid, ^reload_version, _batch_size ->
       [concurrent_event]
     end)

-    expect(MockEventStore, :append_to_stream, fn _meta, ^stream_uuid, 2, _events, _opts ->
+    expect(MockEventStore, :append_to_stream, fn _meta, ^stream_uuid, ^reload_version, _events, _opts ->
       :ok
     end)
   end

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/support/mock_event_store_helpers.ex` around lines 181 - 243, The helper
expect_concurrency_retry_succeeds/2 hardcodes versions (1, 2, 2); make it accept
optional version parameters (e.g., opts with :expected_version and
:reload_version) defaulting to the current values and use those variables in the
MockEventStore expect clauses instead of literals so the append_to_stream and
stream_forward patterns match the supplied versions; update the function head
and docstring to mention the new opts and default values so tests can pass
custom expected/reload versions when needed.